home *** CD-ROM | disk | FTP | other *** search
/ Internet Info 1994 March / Internet Info CD-ROM (Walnut Creek) (March 1994).iso / networking / ip / ka9q / MNetsrc.hqx / Mac TCP_IP Source v.33 / mac_files.c < prev    next >
Text File  |  1989-03-27  |  14KB  |  585 lines
  1. /* mac_files
  2.  * This module contains all the directory stuff within the KA9Q package
  3.  */
  4.  
  5. #include <stdio.h>
  6. #include "global.h"
  7. #include "mac.h"
  8. #include "cmdparse.h"
  9.  
  10. #include "mac_files.h"
  11. #include <HFS.h>
  12.  
  13. extern errno;
  14. extern struct RemoveIt Head;
  15.  
  16. char *CtoPstr(),*PtoCstr();        /* used to interface to Toolbox */
  17.  
  18. /*
  19.  * dir: Create a directory listing in a temp file and return the resulting file
  20.  * descriptor. If full == 1, give a full listing in the temp file; if full
  21.  * == 2, give just a list of names in the temp file; if full ==3, output to
  22.  * console with the full listing. full == 0 is same as full == 2.
  23.  */
  24. FILE *
  25. dir(path,full)
  26. char *path;
  27. int full;
  28. {
  29.     WDPBRec MyDisk;
  30.     CInfoPBRec Everything;
  31.     FILE *fp, *fp1;
  32.     OSErr e;
  33.     char *GetPathname();
  34.  
  35.     char *ptr;
  36.     char buff[256];
  37.     char holding_file[256];
  38.     char working_volume[256];
  39.     char dirname[256];
  40.  
  41.     errno = 0;
  42.  
  43. /* open up dirnet.temp file for the cases we need it, otherwise direct to stdout */
  44.  
  45.     if ( full < 3) {
  46.         if ( ( fp = fopen(dirnet, "w")) == NULL) {
  47.             printf("Open failed, errno = %d\n",errno);
  48.             return((FILE *)NULL);
  49.         }
  50.     }
  51.     else
  52.         fp = stdout;
  53.  
  54. /* start process of getting directory */
  55.     
  56.     MyDisk.ioWDProcID = 0L;
  57.     MyDisk.ioWDDirID = 0L;
  58.     MyDisk.ioVRefNum = 0;
  59.     MyDisk.ioWDVRefNum = 0;
  60.     MyDisk.ioNamePtr = (StringPtr)working_volume;
  61.     if (path[0] == NULL)
  62.         path = ":";
  63.     MoveIt(MyDisk.ioNamePtr, path);
  64.  
  65.     if ( (e = PBOpenWD( &MyDisk, FALSE)) != noErr ) {
  66.  
  67. /*
  68.  * got an error on initial PBOpenWD
  69.  * see if we were passed a file name instead of directory by trying to
  70.  * open it through the library fopen call
  71.  */
  72.         if ( ( fp1 = fopen(path, "r")) == NULL) {
  73.             if (full < 3) {
  74.                 fclose(fp);
  75.                 unlink(dirnet);
  76.             }
  77.             else
  78.                 printf("Can't get directory of '%s'.\n",path);
  79.             return(NULL);
  80.         }
  81.         else {
  82.             fclose(fp1);        /* close the fopen file */
  83.  
  84. /* we were able to open the path as a file.
  85.  * For just the list of file names, strip the latter part
  86.  * of the path and place that in the file. */
  87.  
  88.             if ( (full == 0) || (full == 2) ) {
  89.                 ptr  = rindex(path, ':');
  90.                 if (ptr != NULL)    /* found a :, return stuff to right */
  91.                     ptr++;
  92.                 else
  93.                     ptr = path;        /* no :, return entire path */
  94.                 fprintf(fp,"%s\n", ptr);
  95.                 fclose(fp);            /* close file, reopen as read only */
  96.                 fp = fopen(dirnet, "r");
  97.                 return(fp);
  98.             }
  99.             else {
  100.     /* we have a single file, and we must return full info. Get it. */
  101.                 sprintf(holding_file, "%s", path);
  102.                 CtoPstr(holding_file);
  103.                 Everything.hFileInfo.ioNamePtr = (StringPtr)holding_file;
  104.                 Everything.hFileInfo.ioVRefNum = MyDisk.ioVRefNum;
  105.                 Everything.hFileInfo.ioFDirIndex = 0;
  106.                 Everything.hFileInfo.ioDirID = 0L;
  107.                 Everything.hFileInfo.ioCompletion = 0;
  108.                                 
  109.                 if ( (e = PBGetCatInfo( &Everything, FALSE)) != fnfErr) {
  110.                     ptr = ctime((long *)&Everything.hFileInfo.ioFlCrDat);
  111.                     ptr +=3;
  112.                     ptr[strlen(ptr)-1] = '\0';
  113.                     ptr[strlen(ptr)-8] = '\0';
  114.                     fprintf(fp,"%c %8ld %8ld-rf %s %s  %s\n",
  115.                         (Everything.hFileInfo.ioFlAttrib & (1<<4))?'d':'-',
  116.                         (Everything.hFileInfo.ioFlAttrib & (1<<4))?
  117.                             0:Everything.hFileInfo.ioFlLgLen,
  118.                         (Everything.hFileInfo.ioFlAttrib & (1<<4))?
  119.                             0:Everything.hFileInfo.ioFlRLgLen, ptr, ptr+19,
  120.                         PtoCstr((char *) Everything.hFileInfo.ioNamePtr));
  121.                 }
  122.                 else
  123.                     printf("Error getting directory: %d\n", e);
  124.             }
  125.             if ( full < 3 ) {
  126.                 fclose(fp);
  127.                 fp = fopen(dirnet, "r");
  128.             }
  129.             return(fp);
  130.         }
  131.     }
  132.  
  133. /* original PBOpenWD worked */
  134.  
  135.     if (full == 3)
  136.         fprintf(fp,"Directory of %s\n",GetPathname(dirname,MyDisk.ioVRefNum));
  137.     
  138.     Everything.hFileInfo.ioNamePtr = (StringPtr)holding_file;
  139.     Everything.hFileInfo.ioVRefNum = MyDisk.ioVRefNum;
  140.     sprintf(Everything.hFileInfo.ioNamePtr, "\p");
  141.     Everything.hFileInfo.ioFDirIndex = 1;
  142.     Everything.hFileInfo.ioDirID = MyDisk.ioWDDirID;
  143.     Everything.hFileInfo.ioCompletion = 0;
  144.  
  145.     while( (e = PBGetCatInfo( &Everything, FALSE)) != fnfErr) {
  146.         if ( e == noErr ) {
  147.             if( full == 0) {
  148.                 fprintf(fp, "%s\n",
  149.                      PtoCstr((char *) Everything.hFileInfo.ioNamePtr));
  150.             }
  151.             else {    
  152.                 ptr = ctime((long *)&Everything.hFileInfo.ioFlCrDat);
  153.                 ptr +=3;
  154.                 ptr[strlen(ptr)-1] = '\0';
  155.                 ptr[strlen(ptr)-8] = '\0';
  156.                 fprintf(fp,"%c %8ld %8ld-rf %s %s  %s\n",
  157.                     (Everything.hFileInfo.ioFlAttrib & (1<<4))?'d':'-',
  158.                     (Everything.hFileInfo.ioFlAttrib & (1<<4))?
  159.                         0:Everything.hFileInfo.ioFlLgLen,
  160.                     (Everything.hFileInfo.ioFlAttrib & (1<<4))?
  161.                         0:Everything.hFileInfo.ioFlRLgLen, ptr, ptr+19,
  162.                     PtoCstr((char *) Everything.hFileInfo.ioNamePtr));
  163.             }
  164.             
  165.             Everything.hFileInfo.ioFlLgLen = 0;
  166.             Everything.hFileInfo.ioFDirIndex++;
  167.  
  168.         }
  169.         else
  170.             break;        /* go an error other than fnfErr: break */
  171.  
  172.         Everything.hFileInfo.ioDirID = MyDisk.ioWDDirID;
  173.     }
  174.  
  175. /*
  176.  * either the PBGetCatInfo finally encountered a fnfErr, or some other error
  177.  * occurred. If we were writing a file, close it then reopen it before returning
  178.  * the file pointer to our caller.
  179.  */
  180.     PBCloseWD(&MyDisk, FALSE);
  181.     if ( full < 3) {
  182.         fclose(fp);
  183.         fp = fopen(dirnet, "r");
  184.     }
  185.     return(fp);
  186. }
  187.  
  188. /*
  189.  * mktemp: make temporary filename and return a pointer to it.
  190.  *
  191.  * method: if the string passed has an X in it, insert an 8-digit hexadecimal
  192.  * number based on the current tick count starting at the first X position. If the
  193.  * string passed has no X, insert the 8-digit hexadecimal number starting at
  194.  * the beginning of the string. No action is taken if there is insufficient room
  195.  * to insert the number without extending the passed string.
  196.  */
  197.  
  198. char *mktemp(ff)
  199. char *ff;
  200. {
  201.     char *ptr;
  202.     if ( ( ptr = index(ff, 'x') ) == NULL)
  203.         ptr = ff;
  204.     if (strlen(ptr) >= 8)
  205.         sprintf(ptr, "%lx", (long)TickCount());
  206.     return(ff);
  207. }
  208.  
  209. static struct RemoveIt search_result;
  210.  
  211. /*
  212.  * filedir: search for a file.
  213.  *
  214.  * NOTE: this is not a general file search routine.
  215.  * The search path must have the filename in the form xxxxx.yyyyy. This search
  216.  * code will look for files that match the .yyyyy.
  217.  *
  218.  * filedir(path,value,dest)
  219.  * The name of the matched file (just the filename, no folder/path info) will
  220.  * be returned in dest. An empty dest (first value NULL) indicates no match.
  221.  *
  222.  * value =0: start a new search thread.
  223.  * value =1: use the last search thread, provide the next file match.
  224.  */
  225. int filedir(path,value,dest)
  226. char *path;
  227. int value;
  228. char *dest;
  229. {
  230.     WDPBRec MyDisk;
  231.     CInfoPBRec Everything;
  232.     FILE *fp1;
  233.     OSErr e;
  234.  
  235.     char *GetPathname();
  236.     char *ptr,*name_ptr;
  237.     char keep;
  238.     char holding_file[256];
  239.     char working_volume[256];
  240.     char search_string[256];
  241.     char *NLreturn_first();
  242.  
  243.     dest[0] = NULL;        /* initialize return value */
  244.     
  245. /* first, see if this is a new search thread. If so, we must first clean up any
  246.  * outstanding search_result structure.
  247.  */
  248.     if (value == 0) {
  249.         NLdelete_all(&search_result);
  250.         errno = 0;
  251.  
  252.     /* start process of getting directory */
  253.         MyDisk.ioWDProcID = 0L;
  254.         MyDisk.ioWDDirID = 0L;
  255.         MyDisk.ioVRefNum = 0;
  256.         MyDisk.ioWDVRefNum = 0;
  257.         MyDisk.ioNamePtr = (StringPtr)working_volume;
  258.  
  259.     /* establish our path name */
  260.         if (path[0] == NULL)
  261.             strcpy(search_string,":");
  262.         else
  263.             strcpy(search_string,path);
  264.  
  265.     /* see if we have a path with folder info or just a filename */
  266.         if ( (ptr = rindex(search_string, ':')) != NULL) {
  267.             keep = *ptr;
  268.             *ptr = '\0';
  269.             MoveIt(MyDisk.ioNamePtr, search_string);
  270.             *ptr = keep;
  271.         }
  272.         else
  273.             MoveIt(MyDisk.ioNamePtr, search_string);
  274.  
  275.         if ( ( name_ptr = rindex( search_string, '.')) != NULL)
  276.             name_ptr++;
  277.         else
  278.             name_ptr = "";
  279.  
  280.     /*open the working directory */
  281.         if ( (e = PBOpenWD( &MyDisk, FALSE) != noErr) ) {
  282.  
  283.     /* got an error on initial PBOpenWD - see if we were passed a file name
  284.      * instead of directory by trying to open it through the library fopen call
  285.      */
  286.             if ( ( fp1 = fopen(search_string, "r")) == NULL)
  287.                 return(-1);
  288.             fclose(fp1);        /* close the fopen file */
  289.  
  290.     /* we were able to open the path as a file - return the single file name */
  291.  
  292.             ptr  = rindex(search_string, ':');
  293.             if (ptr != NULL)    /* found a :, return stuff to right */
  294.                 ptr++;
  295.             else
  296.                 ptr = search_string;        /* no :, return entire path */
  297.             strcpy(dest,ptr);    /* copy our single result */
  298.             return(0);
  299.         }
  300.  
  301.     /* original PBOpenWD worked */
  302.     
  303.         Everything.hFileInfo.ioNamePtr = (StringPtr)holding_file;
  304.         Everything.hFileInfo.ioVRefNum = MyDisk.ioVRefNum;
  305.         Everything.hFileInfo.ioFDirIndex = 1;
  306.         Everything.hFileInfo.ioDirID = MyDisk.ioWDDirID;
  307.         Everything.hFileInfo.ioCompletion = 0;
  308.  
  309.         while( (e = PBGetCatInfo( &Everything, FALSE)) != fnfErr) {
  310.             if ( e == noErr ) {
  311.  
  312.                 PtoCstr(holding_file);
  313.                 if ( ( ptr = rindex( holding_file, '.')) != NULL) {
  314.                     ptr++;
  315.                     if ( strncmp(ptr, name_ptr, strlen(name_ptr)) == 0)
  316.                         NLadd_name(holding_file, &search_result);
  317.                 }
  318.                 Everything.hFileInfo.ioFlLgLen = 0;
  319.                 Everything.hFileInfo.ioFDirIndex++;
  320.                 Everything.hFileInfo.ioDirID = MyDisk.ioWDDirID;
  321.             }
  322.             else
  323.                 break;        /* got an error other than fnfErr: break */
  324.         }
  325.  
  326. /* either the PBGetCatInfo finally saw a fnfErr, or some other error occurred. */
  327.  
  328.         PBCloseWD(&MyDisk, FALSE);
  329.     }
  330.  
  331. /* either we are on a search continuation or have finished the data gathering phase */
  332.  
  333.     if ((ptr = NLreturn_first(&search_result)) != NULL) {
  334.         strcpy(dest,ptr);
  335.         NLdelete_first(&search_result);
  336.         return(0);
  337.     }
  338.     return(-1);
  339. }
  340.  
  341. /*
  342.  * tmpfile: create a temporary file.  Remember it so we can delete it later because
  343.  * the mac does not allow the file to be deleted when it is open.
  344.  */
  345.  
  346. FILE *
  347. tmpfile()
  348. {
  349.     FILE *tmp;
  350.     char *mktemp();
  351.     char *ptr;
  352.     char tmpname[16]; 
  353.     
  354.     strcpy(tmpname,"SMTPxxxxxxxx");
  355.     if ( ( ptr = malloc(strlen(temppath)+strlen(tmpname)+1)) == NULLCHAR) {
  356.         printf("tmpfile: can't allocate memory.\n");
  357.         return(NULL);
  358.     }
  359.     (void) mktemp(tmpname);            /* replace the xxxxxxxx with something else */
  360.     sprintf(ptr,"%s%s",temppath,tmpname);
  361.     if ( ( tmp = fopen(ptr, "w+") ) == NULL) {
  362.         printf("tmpfile: could not create temp file (%s)\n", ptr);
  363.         (void)free(ptr);    /* free up our original name storage */
  364.         return(NULL);
  365.     }
  366.  
  367. /* save away the name of the file so we can delete it when exiting (ignore
  368.  * errors, if we can't delete at exit it won't harm anything). */
  369.  
  370.     NLadd_name(ptr,&Head);
  371.     (void)free(ptr);    /* free up our original name storage */
  372.     return (tmp);        /* return file pointer to the file we opened */
  373. }
  374.  
  375. /*
  376.  * Access: check the file for access permission.  Some of this has to be faked on
  377.  * a Mac, since it does not have access bits.
  378.  *
  379.  * returned value = 0: OK
  380.  * returned value = 1: reject
  381.  */
  382.  
  383. int
  384. access(str, perm)
  385.  char *str;
  386.  int perm;
  387. {
  388.     FILE *fptr;
  389.     CInfoPBRec    paramBlock;
  390.     OSErr e;
  391.  
  392.     paramBlock.hFileInfo.ioCompletion = 0;
  393.     paramBlock.hFileInfo.ioVRefNum = 0;
  394.     paramBlock.hFileInfo.ioFDirIndex = 0;
  395.     paramBlock.hFileInfo.ioDirID = 0;
  396.     paramBlock.hFileInfo.ioNamePtr = (StringPtr) CtoPstr(str);
  397.  
  398.     /*
  399.      * Get info on file named in ioNamePtr
  400.      */
  401.      
  402.     e = PBGetCatInfo( ¶mBlock, FALSE);
  403.     PtoCstr(str);
  404.     
  405.     /*
  406.      * if there is an error then find out if the file is present.  If so
  407.      * see if user wants to create the file
  408.      */
  409.      
  410.     if ( e != noErr ) {
  411.         if ( ( e == fnfErr) && (perm == 2))
  412.             return(0);
  413.         else
  414.             return(1);
  415.     }
  416.     /*
  417.      * check to see if the file is locked or open.  refuse it if it is.
  418.      */
  419.      
  420.     if ( (BitTst( ¶mBlock.hFileInfo.ioFlAttrib, 0) 
  421.             || BitTst( ¶mBlock.hFileInfo.ioFlAttrib, 7) ) && perm == 4 )
  422.         return(1);
  423.     else
  424.         return(0);
  425. }
  426.  
  427. /* List directory to console */
  428. dodir(argc,argv)
  429. int argc;
  430. char *argv[];
  431. {
  432.     switch (argc) {
  433.         case 1:
  434.             dir(":",3);
  435.             break;
  436.         case 2:
  437.             dir( argv[1], 3);
  438.             break;
  439.  
  440.         default:
  441.             printf("Cannot accept %d arguments to DIR\n", argc-1);
  442.             return(1);
  443.     }            
  444.     
  445.     return (0);
  446. }
  447.  
  448. /*
  449.  * docd: perform a change directory
  450.  */
  451.  
  452. docd(argc, argv)
  453. int argc;
  454. char *argv[];
  455. {
  456.     char dirname[256];
  457.     char *GetPathname();
  458.     int WDVRefNum;
  459.  
  460.     if (argc > 1) {
  461.         if (chdir(argv[1],&WDVRefNum) != 0) {
  462.             printf("Can't change directory.\n");
  463.             return (1);
  464.         }
  465.     }
  466.     else
  467.         if (chdir(":",&WDVRefNum) != 0) {
  468.             printf("Can't report directory.\n");
  469.             return (1);
  470.         }
  471.     printf(" Path = %s\n",GetPathname(dirname,WDVRefNum));
  472.     return (0);
  473. }
  474.  
  475. /* chdir
  476.  * This routine changes the working directory to the path specified.
  477.  * The WDVRefNum for the new directory is returned.
  478.  */
  479.  
  480. int chdir( path, WDVRefNum )
  481. char *path;
  482. int *WDVRefNum;
  483. {
  484.     WDPBRec MyDisk;
  485.     OSErr e;
  486.     char ourpath[256];
  487.  
  488. /* prep the parameter block */
  489.     MyDisk.ioWDProcID = 0L;
  490.     MyDisk.ioWDDirID = 0L;
  491.      MyDisk.ioVRefNum = 0;
  492.     MyDisk.ioWDVRefNum = 0;
  493.     
  494. /* handle our single argument */
  495.     if (path[0] == NULL)
  496.         MoveIt(ourpath,":");
  497.     else
  498.         MoveIt(ourpath,path);
  499.     MyDisk.ioNamePtr = (StringPtr)ourpath;
  500.  
  501. /* open working directory */
  502.     if ((e = PBOpenWD( &MyDisk, FALSE)) != noErr)
  503.         return(-1);
  504.     
  505. /* make the working directory the default */
  506.     MyDisk.ioNamePtr = NULL;
  507.     if ( ( e = PBHSetVol( &MyDisk, FALSE) ) != noErr)
  508.         return(-1);
  509.  
  510. /* return the VRefNum in case the caller wants to generate a pathname */
  511.     *WDVRefNum = MyDisk.ioVRefNum;
  512.  
  513.     return(0);
  514. }
  515.  
  516. mkdir(name, mode)
  517. char *name;
  518. int mode;
  519. {
  520.  
  521.     HParamBlockRec paramBlock;
  522.     int e;
  523.     
  524.     paramBlock.fileParam.ioCompletion = 0;
  525.     paramBlock.fileParam.ioNamePtr = (StringPtr) CtoPstr(name);
  526.     paramBlock.fileParam.ioDirID = 0L;
  527.     paramBlock.fileParam.ioVRefNum = 0;
  528.  
  529.     if ( ( e = PBDirCreate(¶mBlock, FALSE)) != 0 ) {
  530.         printf("Could not create directory, error = %d\n", e);
  531.         return(-1);
  532.     }
  533.     return(0);
  534. }
  535.  
  536. rmdir(name)
  537. char *name;
  538. {
  539.     HParamBlockRec paramBlock;
  540.     int e;
  541.     
  542.     paramBlock.fileParam.ioCompletion = 0;
  543.     paramBlock.fileParam.ioNamePtr = (StringPtr) CtoPstr(name);
  544.     paramBlock.fileParam.ioFVersNum = 0;
  545.     paramBlock.fileParam.ioVRefNum = 0;
  546.     
  547.     if ( ( e = PBDelete(¶mBlock, FALSE)) != 0 ) {
  548.         printf("Could not delete directory, error = %d\n", e);
  549.         return(-1);
  550.     }
  551.     return(0);
  552. }
  553.  
  554. GetFileInfo(vol,name,iop)
  555. short vol;
  556. char *name;
  557. FileParam *iop;
  558. {
  559.     iop->ioNamePtr = (StringPtr)name;
  560.     iop->ioVRefNum=vol;
  561.     iop->ioFVersNum=iop->ioFDirIndex=0;
  562.     PBGetFInfo(iop, FALSE);
  563. }
  564.  
  565. SetFileInfo(vol,name,iop)
  566. short vol;
  567. char *name;
  568. FileParam *iop;
  569. {
  570.     iop->ioNamePtr = (StringPtr)name;
  571.     iop->ioVRefNum=vol;
  572.     iop->ioFVersNum=iop->ioFDirIndex=0;
  573.     PBSetFInfo(iop, FALSE);
  574. }
  575.  
  576. MakeTextFile(vol,name,iop)
  577. short vol;
  578. char *name;
  579. FileParam *iop;
  580. {    GetFileInfo(vol,name,iop);
  581.     iop->ioFlFndrInfo.fdType='TEXT';
  582.     iop->ioFlFndrInfo.fdCreator='EDIT';
  583.     SetFileInfo(vol,name,iop);
  584. }
  585.